/**
 * 
 * 给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
 */
// [1, 1, 1, 1, 2, 3, 4, 4, 4, 5]
// [1, 1, 2, 3, 4, s3, f4, 4, f4, f5]
function removeDuplicates(nums = []) {
    // let slow = 0, fast = 1;
    // let num = 0;
    // for (fast = 1; fast < arr.length; fast++) {
    //     if (arr[slow] === arr[fast]) {
    //         // num++;
    //         if (++num >= 2) {
    //             slow++;
    //         }
    //         continue;
    //     }
    //     num = 0;
    //     // else {
    //     //     if (num >= 2) {
    //     //         slow = slow + 1 + (num - 2);
    //     //         num = 0;
    //     //     } else {
    //     //         slow = slow + 1;
    //     //     }
    //     //     arr[slow] = arr[fast];
    //     // }
    //     arr[slow++] = arr[fast];
    // }
    // console.log("出现大于2个的数值", arr);
    // return arr.slice(0, slow + 1);
    /**
     * [1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5]
     * [0, 1, 2, #2, 3, sf3, 4, #4, 5, s4, 4, 4, 5]
     *  0,  1, 2,  3 
     * */

    // const n = nums.length;
    // if (n <= 2) {
    //     return n;
    // }
    // let slow = 0, fast = 0;
    // let num = 0;
    // while (fast < n) {
    //     if (nums[slow] === nums[fast]) {
    //         num++;
    //         fast++;
    //         continue;
    //     }
    //     if (num >= 2) {
    //         let start = slow + 2;
    //         let l = 0;
    //         while (l < num - 1) {
    //             nums[start++] = nums[fast];
    //             l++;
    //             fast++;
    //         }
    //         slow = start;
    //         num = 0;
    //     }
    //     slow++;
    //     fast++;
    // }

    const n = nums.length;
    if (n <= 2) {
        return n;
    }
    let slow = 2, fast = 2;
    while (fast < n) {
        if (nums[slow - 2] != nums[fast]) {
            nums[slow] = nums[fast];
            ++slow;
        }
        ++fast;
    }
    console.log("出现大于2个的数值", nums);
    return slow;
}
removeDuplicates([1, 1, 2, 3, 3, 2, 3, 3, 4, 4, 4, 4, 5]);
/**
 * 给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素
 * ，使每个元素 只出现一次，
 * 返回删除后数组的新长度。
 * 元素的 相对顺序 应该保持 一致 。
 */
/**
 * 使用双指针来实现排序数组的去重
 * @param {*} arr 
 * @returns 
 */
function findOnlyOne(arr = []) {
    let slow = 0, fast = 0;
    while (fast < arr.length) {
        if (arr[slow] === arr[fast]) {
            fast++;
            continue;
        }
        arr[++slow] = arr[fast];
        fast++;
    }
    // for (fast = 0; fast < arr.length; fast++) {
    //     if (arr[slow] === arr[fast]) {
    //         continue;
    //     }
    //     // if (arr[slow] !== arr[fast]) {
    //     arr[++slow] = arr[fast];
    //     // }
    // }
    return arr.slice(0, slow + 1);
}

console.log("【升序排列】", findOnlyOne([1, 1, 1, 2, 3, 4, 4, 4, 5]))
// 其实上面的案例可以扩展出很多其他案例，比如去掉所有的某个数值，
// 数组不一定是有序的，
/**
 * 删除数组中所有值为target的值，也是使用双指针来解决
 * [1,0,2,3,4,0,5]
 * [1,2,3,4,s4,0,f5]
 * @param {*} arr 
 * @param {*} target 
 * @returns 
 */
function findDelOne(arr = [], target) {
    let slow = 0, fast = 0;
    for (fast = 0; fast < arr.length; fast++) {
        if (arr[fast] === target) {
            continue;
        }
        arr[slow++] = arr[fast];
        // if (arr[fast] !== target && arr[slow] === target) {
        //     let tmp = arr[fast + 1];
        //     arr[slow] = arr[fast + 1];
        //     arr[fast + 1] = tmp;
        //     slow = fast + 1;
        //     fast++;
        // }
    }
    return arr.slice(0, slow);
}

console.log("【删除指定数值】", findDelOne([1, 0, 2, 3, 4, 0, 5], 0))

/*
给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 一次 或 两次 。
请你找出所有出现 两次 的整数，并以数组形式返回。
你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问题。
*/


var findDuplicates = function (nums) {
    const ans = new Array()
    for (let i = 0; i < nums.length; i++) {
        const org = Math.abs(nums[i]);
        // console.log(org - 1);
        /**
         * [4,3,2,7,8,2,3,1]
         * org = 4,
         * numbs[3]>0
         * numbs[3]=-7
         * 
         * org = 3;
         * numbs[2]>0
         * numbs[2] = - 2
         * 
         * org = 2;
         * numbs[1]>0
         * numbs[1] = -3;
         * 
         * arg = 7;
         * numbs[6]>0
         * numbs[6] = -3;
         * 
         * arg = 8;
         * numbs[7]>0;
         * numbs[7] = -1;
         * 
         * arg = 2;
         * numbs[1]
         */
        if (nums[org - 1] > 0)
            nums[org - 1] *= -1
        else
            ans.push(org)
    }
    return ans
};

console.log("重复出现两次", findDuplicates([4, 3, 2, 7, 8, 2, 3, 1]));